128 research outputs found
Simple and Optimal Randomized Fault-Tolerant Rumor Spreading
We revisit the classic problem of spreading a piece of information in a group
of fully connected processors. By suitably adding a small dose of
randomness to the protocol of Gasienic and Pelc (1996), we derive for the first
time protocols that (i) use a linear number of messages, (ii) are correct even
when an arbitrary number of adversarially chosen processors does not
participate in the process, and (iii) with high probability have the
asymptotically optimal runtime of when at least an arbitrarily
small constant fraction of the processors are working. In addition, our
protocols do not require that the system is synchronized nor that all
processors are simultaneously woken up at time zero, they are fully based on
push-operations, and they do not need an a priori estimate on the number of
failed nodes.
Our protocols thus overcome the typical disadvantages of the two known
approaches, algorithms based on random gossip (typically needing a large number
of messages due to their unorganized nature) and algorithms based on fair
workload splitting (which are either not {time-efficient} or require intricate
preprocessing steps plus synchronization).Comment: This is the author-generated version of a paper which is to appear in
Distributed Computing, Springer, DOI: 10.1007/s00446-014-0238-z It is
available online from
http://link.springer.com/article/10.1007/s00446-014-0238-z This version
contains some new results (Section 6
Predictive caching and prefetching of query results in search engines
We study the caching of query result pages in Web search engines. Popular search engines receive millions of queries per day, and ecient policies for caching query results may enable them to lower their response time and reduce their hardware requirements. We present PDC (probability driven cache), a novel scheme tailored for caching search results, that is based on a probabilistic model of search engine users. We then use a trace of over seven million queries submitted to the search engine AltaVista to evaluate PDC, as well as traditional LRU and SLRU based caching schemes. The trace driven simulations show that PDC outperforms the other policies. We also examine the prefetching of search results, and demonstrate that prefetching can increase cache hit ratios by 50% for large caches, and can double the hit ratios of small caches. When integrating prefetching into PDC, we attain hit ratios of over 0:53.
The Firing Squad Problem Revisited
In the classical firing squad problem, an unknown number of nodes represented by identical finite state machines is arranged on a line and in each time unit each node may change its state according to its neighbors\u27 states. Initially all nodes are passive, except one specific node located at an end of the line, which issues a fire command. This command needs to be propagated to all other nodes, so that eventually all nodes simultaneously enter some designated ``firing" state.
A natural extension of the firing squad problem, introduced in this paper, allows each node to postpone its participation in the squad for an arbitrary time, possibly forever, and firing is allowed only after all nodes decided to participate. This variant is highly relevant in the context of decentralized distributed computing, where processes have to coordinate for initiating various tasks simultaneously.
The main goal of this paper is to study the above variant of the firing squad problem under the assumptions that the nodes are infinite state machines, and that the inter-node communication links can be changed arbitrarily in each time unit, i.e., are defined by a dynamic graph. In this setting, we study the following fundamental question: what connectivity requirements enable a solution to the firing squad problem?
Our main result is an exact characterization of the dynamic graphs for which the firing squad problem can be solved. When restricted to static directed graphs, this characterization implies that the problem can be solved if and only if the graph is strongly connected. We also discuss how information on the number of nodes or on the diameter of the network, and the use of randomization, can improve the solutions to the problem
Diagonalization Games
We study several variants of a combinatorial game which is based on Cantor's
diagonal argument.
The game is between two players called Kronecker and Cantor. The names of the
players are motivated by the known fact that Leopold Kronecker did not
appreciate Georg Cantor's arguments about the infinite, and even referred to
him as a "scientific charlatan". In the game Kronecker maintains a list of m
binary vectors, each of length n, and Cantor's goal is to produce a new binary
vector which is different from each of Kronecker's vectors, or prove that no
such vector exists. Cantor does not see Kronecker's vectors but he is allowed
to ask queries of the form"What is bit number j of vector number i?" What is
the minimal number of queries with which Cantor can achieve his goal? How much
better can Cantor do if he is allowed to pick his queries \emph{adaptively},
based on Kronecker's previous replies? The case when m=n is solved by
diagonalization using n (non-adaptive) queries. We study this game more
generally, and prove an optimal bound in the adaptive case and nearly tight
upper and lower bounds in the non-adaptive case.Comment: 11 pages, added acknowledgement
Self Masking for Hardering Inversions
The question whether one way functions (i.e., functions that are easy to compute but hard to invert) exist is arguably one of the central problems in complexity theory, both from theoretical and practical aspects. While proving that such functions exist could be hard, there were quite a few attempts to provide functions which are one way in practice , namely, they are easy to compute, but there are no known polynomial time algorithms that compute their (generalized) inverse (or that computing their inverse is as hard as notoriously difficult tasks, like factoring very large integers).
In this paper we study a different approach. We provide a simple heuristic, called self masking, which converts a given polynomial time computable function into a self masked version , which satisfies the following: for a random input , w.h.p., but a part of , which is essential for computing is masked in . Intuitively, this masking makes it hard to convert an efficient algorithm which computes to an efficient algorithm which computes , since the masked parts are available to but not to .
We apply this technique on variants of the subset sum problem which were studied in the context of one way functions, and obtain functions which, to the best of our knowledge, cannot be inverted in polynomial time by published techniques
- …